import java.util.Vector;


public class Scoring {
	char[] score;
	int[] deck;
	Card[] c;
	private final int c_charplus= 66; //65. ist das A, ab B gibt es bewertungen
	
	public Scoring(){
		score = new char[9];
		deck = new int[52];
		
		for(int i=0;i<9;i++)
			score[i] = 'A';
		for(int i=0;i<52;i++)
			deck[i]=0;
	}
	
	public char[] scorethese(Card[] h, Card[] b){
		//System.out.println(h.toString());
		//System.out.println(b.toString());
		
		for(int i=0;i<9;i++)
			score[i] = 'A';
	
		for(int i=0;i<52;i++)
			deck[i]=0; //reset
		
		
		c = new Card[7];
		for(int j = 0;j<7;j++){
			if(j<2)
				c[j] = h[j];
			else
				c[j] = b[j-2];
		}
		
		for(Card item:c)
			deck[item.cardid()] = 1;
	
	/*	for(int i = 0; i<52; i++){
			System.out.print(deck[i]+" ");
			if((i+1)%13==0)
				System.out.println();
		} */
		
		char[] retchar = this.pairing();
		score[2] = retchar[4];
		score[6] = retchar[3];
		score[1] = retchar[2];
		score[5] = retchar[1];
		score[7] = retchar[0]; //quads fh trips twopairs pairs erkannt
		score[3] = fl();
		score[8] = hc(h); //jeweilige highcard
		
		/* score[0] = sf(c); score[1] = qu(c); score[2] = fh(c);
		score[3] = fl(c); score[4] = st(c); score[5] = tr(c);
		score[6] = tp(c); score[7] = p(c);  score[8] = hc(c); */
		this.fl();
	
		return score;
	}
	
	
	private char[] pairing(){
		Vector<Integer> myvec= new Vector<Integer>();
		char[] retchar = new char[5];
		
		for(int i = 0; i<5; i++)
			retchar[i]='A';
		
		for(int i = 0; i <13; i++){
				myvec.add(deck[i]+deck[i+13]+deck[i+26]+deck[i+39]);
		}
		
		boolean pair=false;
		boolean trips=false; // für twopair und fh erkennung
		
		for(int j=4;j>1;j--){ //von quads runter zu pairs
			if(myvec.contains(j)){ //ist das in den zusammengezählten reihen drin?
				for(int i=0;i<13;i++){ // von oben runterzählen bei den karten
					if(myvec.elementAt(i)==j){
						
						if(j==2 && !pair)
							pair=true;
						else if(j==2 && pair)//twopair
							retchar[3] = retchar[0]; //wir müssen das kleinere nehmen
						if(j==3 && !trips)
							trips=true;
						else if(j==2 && trips)//fh
							retchar[4] = retchar[1]; //wir nehmen das pair dazu
						
						
						retchar[j-2] =  (char) (i+65+1); //muss ja auch "nix" geben
					}
				}
				
			}
		}
		return retchar;
	}
	

	
	private char fl(){
		Vector<Integer> myvec= new Vector<Integer>();
		int linesum;
		for(int i=0;i<4;i++){
			linesum=0;
			for(int j=0;j<13;j++){
				linesum+=deck[j+(i*13)];
			}
			myvec.add(linesum);
		} //wenn das >=5, flush entdeckt
		if(myvec.contains(5) || myvec.contains(6) || myvec.contains(7)){
			//in welcher farbe denn?
			int col=-1;
			for(int i=0;i<4;i++){
				if(myvec.elementAt(i)>=5){
					col=i;
					break; }
			}
			//jetzt müssen wir die höchste karte vom eigenem anteil bestimmen, 
			//wenn nicht vorhanden einfach kleinste vom board übergeben..
			if(c[0].getCard()[1]==col)
				return ((char) (c[0].getCard()[0]+65+1));
			else if(c[1].getCard()[1]==col)
				return ((char) (c[1].getCard()[0]+65+1));
			else {
				int low=13;
				//niedrigste karte vom board
				for(int x=2;x<7;x++){
					if(c[x].getCard()[0]<low)
						low=c[x].getCard()[0];
				}
				return((char)(low+65+1));
			}
		}
		
		//System.out.println(myvec);
		return 'A';
	}
	
	private char st(Card[] c){
		return 'A';
	}
	
	private char hc(Card[] c){
		//wenn die highcard nichts zählt, dann gebe einfach 'A' zurück
		//zählt auf jeden fall nichts bei jeder 5 karten hand!
		//sf, fh, flush, straße
		if((this.score[0]+this.score[2]+this.score[3]+this.score[4]>4*65))
			return 'A';
		
		//bei quads und twopairs die jeweiligen vier karten aus der matrix kürzen, dann die höchste verbleibende als kicker..
		if(this.score[1]>65){
			int loc = this.score[1]-c_charplus;
			this.delrow(loc); //alle auf null setzen
			
			//jetzt den höchsten verbleibenden finden und danach löschen
			return (char) this.findhighest(true);
		}
		
		if(this.score[6]>65){ //twopair
			int loc1 = this.score[6]-c_charplus;
			int loc2 = this.score[7]-c_charplus;
			this.delrow(loc1);
			this.delrow(loc2);
			return (char) this.findhighest(true);
		}
		
		if(this.score[5]>65){
			//trips erkannt, hier gibt es im prinzip 2 highcards
			int loc = this.score[5]-c_charplus;
			this.delrow(loc);
			return (char) this.findhighest(true);
 		}
		
		if(this.score[7]>65){ //onepair
			int loc=this.score[7]-c_charplus;
			this.delrow(loc);
			return (char) this.findhighest(true);
			//hier gibt es im prinzip noch 3 kicker?!
		}
		
		char retchar = (c[0].getvalue()) >(c[1].getvalue()) ? (char)(c[0].getvalue()+c_charplus):(char)(c[1].getvalue()+c_charplus);
		//vorsicht wenn höchste karte ein pair macht
		return retchar;
	}
	
	private void delrow(int row){
		for(int i=0;i<4;i++)
			deck[row+i*13]=0;
	}
	
	private int findhighest(boolean del){
		//findet und returned den momentan höchsten im deck verbliebenen score
		int score=0;
		for(int i = 12;i>=0;i--){
			for(int j=3;j>=0;j--){
				if(deck[i+j*13]!=0){
					score=i;
					if(del)
						deck[i+j*13]=0;
					return (score+c_charplus);
				}
			}
		}
		return c_charplus;
	}

}
